import type { Commit, LocatedObject, TreeEntry } from "./git/types.ts";
import { log, objectAt, type PathChange, pathHistory } from "./git/walk.ts";
import { detectLanguage, languageGroup } from "./languages.ts";
import { paginate } from "./pagination.tsx";
import { canonical, encodePath, href, kindAtTip, type Site, type View } from "./route.ts";
import { humanSize, identityDate, looksBinary, looksGenerated, plural, utf8 } from "./util.ts";

const TREE = 0o040000;
const SYMLINK = 0o120000;
const GITLINK = 0o160000;
const HISTORY_PREFETCH = 25;
const kindOf = (entry: TreeEntry) => entry.mode & 0o170000;

async function entriesAt(site: Site, commit: Commit, path: string[]): Promise<TreeEntry[]> {
  const object = await objectAt(site.repo, commit.tree, path);
  if (!object || (object.mode & 0o170000) !== TREE) throw new Error(`${path.join("/")} is not a tree`);
  return site.repo.tree(object.oid);
}

/** `a/b/c` when `a` holds only `b`, which holds only `c`: a chain of lone
 * directories reads better as one link than as three clicks */
async function collapseLoneDirs(site: Site, entry: TreeEntry): Promise<string[]> {
  const names = [entry.name];
  let oid = entry.oid;
  for (;;) {
    const [only, ...rest] = await site.repo.tree(oid);
    if (rest.length > 0 || !only || kindOf(only) !== TREE) return names;
    names.push(only.name);
    oid = only.oid;
  }
}

/** the same shape as the static topbar, minus the ref switcher: the commit
 * panel above already says which commit this is */
export async function topbar(site: Site, view: View, stats: string[], actions: Node[] = []): Promise<HTMLElement> {
  const { name } = site;
  const { kind, oid, path } = view;
  const crumbs = (<nav class="crumbs" />) as HTMLElement;
  const isRoot = kind !== "language" && kind !== "commit" && path.length === 0;
  if (isRoot) crumbs.append(<span class="cur">{name}</span>);
  else crumbs.append(<a href={await href(site, { kind: "tree", oid, path: [] })}>{name}</a>);
  if (kind === "language") crumbs.append(<span class="label">language:</span>, " ", <span class="cur">{path[0]}</span>);
  else if (kind === "commit") crumbs.append(<span class="label">commit:</span>, " ", <span class="cur">{oid.slice(0, 7)}</span>);
  else {
    for (let i = 0; i < path.length; i++) {
      crumbs.append(" / ");
      if (i < path.length - 1) {
        crumbs.append(<a href={await href(site, { kind: "tree", oid, path: path.slice(0, i + 1) })}>{path[i]}</a>);
      } else {
        crumbs.append(<span class="cur">{path[i]}</span>);
        if (kind === "tree") crumbs.append(" /");
      }
    }
  }

  if (kind === "tree" || kind === "blob") {
    actions.unshift(<a href={await href(site, { kind: "history", oid, path })}>history</a>);
  }
  return (
    <header class="topbar">
      {crumbs}
      <span class="view-stats">{stats.map(stat => <span>{stat}</span>)}</span>
      <span class="actions">{actions}</span>
    </header>
  ) as HTMLElement;
}

function commitPanel(commit: Commit): HTMLElement {
  return (
    <p class="snapshot-commit">
      <span class="commit-author">{commit.author.name}</span>
      <a class="commit-message" href={`#commit/${commit.oid}`}>{commit.message.split("\n")[0]}</a>
      <a class="snapshot-sha sha" href={`#commit/${commit.oid}`}>{commit.oid.slice(0, 7)}</a>
      <time>{identityDate(commit.author).slice(0, 10)}</time>
    </p>
  ) as HTMLElement;
}

export async function treeView(site: Site, view: View): Promise<Node[]> {
  const { oid, path } = view;
  await site.repo.prefetch([oid], { smart: "tree" });
  const commit = await site.repo.commit(oid);
  const entries = await entriesAt(site, commit, path);
  // directories first, then byte order, as git and the static pages
  entries.sort((a, b) => Number(kindOf(a) !== TREE) - Number(kindOf(b) !== TREE) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
  const folders = entries.filter(entry => kindOf(entry) === TREE).length;
  const files = entries.length - folders;
  const stats = [folders ? plural(folders, "folder") : "", files ? plural(files, "file") : ""].filter(Boolean);
  const rows = await Promise.all(entries.map(async entry => {
    const kind = kindOf(entry);
    if (kind === GITLINK) return { name: `${entry.name} @ ${entry.oid.slice(0, 7)}` };
    const names = kind === TREE ? await collapseLoneDirs(site, entry) : [entry.name];
    const name = names.join("/") + (kind === TREE ? "/" : kind === SYMLINK ? "@" : "");
    return { name, href: await href(site, { kind: kind === TREE ? "tree" : "blob", oid, path: [...path, ...names] }) };
  }));
  return [
    commitPanel(commit),
    await topbar(site, view, stats),
    <h2 class="file-heading">files</h2>,
    listing(rows),
  ];
}

function listing(rows: Array<{ name: string; href?: string }>): HTMLTableElement {
  const table = (<table class="list" />) as HTMLTableElement;
  for (const { name, href } of rows) {
    table.append(<tr><td>{href ? <a href={href}>{name}</a> : name}</td></tr>);
  }
  return table;
}

/** every file at the commit classified as `language`, flat: a filtered tree
 * would need the filter carried through every directory link */
export async function languageView(site: Site, view: View): Promise<Node[]> {
  const { oid, path: [language] } = view;
  await site.repo.prefetch([oid], { smart: "tree" });
  const commit = await site.repo.commit(oid);
  const paths: string[][] = [];
  const walk = async (tree: string, prefix: string[]) => {
    for (const entry of await site.repo.tree(tree)) {
      const path = [...prefix, entry.name];
      const kind = kindOf(entry);
      if (kind === TREE) {
        // trailing slash so the directory is tested as a parent, not a file
        if (!looksGenerated(`${path.join("/")}/`)) await walk(entry.oid, path);
      } else if (kind !== SYMLINK && kind !== GITLINK && !looksGenerated(path.join("/"))) {
        const grammar = detectLanguage(entry.name);
        if (grammar && languageGroup(grammar) === language) paths.push(path);
      }
    }
  };
  await walk(commit.tree, []);
  const rows = await Promise.all(paths.map(async path => ({
    name: path.join("/"),
    href: await href(site, { kind: "blob", oid, path }),
  })));
  return [
    commitPanel(commit),
    await topbar(site, view, [plural(paths.length, "file")]),
    <h2 class="file-heading">files</h2>,
    listing(rows),
  ];
}

export async function blobView(site: Site, view: View): Promise<Node[]> {
  const { oid, path } = view;
  if (path.length === 0) throw new Error("blob path is empty");
  const commit = await site.repo.commit(oid);
  const object = await objectAt(site.repo, commit.tree, path);
  if (!object || (object.mode & 0o170000) === TREE || (object.mode & 0o170000) === GITLINK) {
    throw new Error(`${path.join("/")} is not a blob`);
  }
  const data = await site.repo.blob(object.oid);
  const raw = <a class="raw" href={`${site.page.base}/raw/${object.oid}/${encodePath(path)}`}>raw</a>;
  const symlink = (object.mode & 0o170000) === SYMLINK;
  const renderable = !symlink && !looksBinary(data) && data.length <= 1 << 20;
  const text = renderable ? utf8.decode(data) : "";
  const lines = text.split("\n");
  if (lines.at(-1) === "") lines.pop();
  const stats = symlink
    ? [`symlink → ${utf8.decode(data)}`]
    : renderable
    ? [humanSize(data.length), plural(lines.length, "line")]
    : [looksBinary(data) ? "binary file" : "large file", humanSize(data.length)];
  const head = [commitPanel(commit), await topbar(site, view, stats, [raw])];
  if (!renderable) return head;

  const source = (
    <pre class="code src historical-code">{lines.map((line, i) =>
      <span class="code-line">
        <span class="ln">{String(i + 1)}</span>
        <span class="code-text">{line}</span>
        {i < lines.length - 1 ? <span class="code-break">{"\n"}</span> : ""}
      </span>
    )}</pre>
  ) as HTMLPreElement;
  void import("./highlight.ts")
    .then(module => module.highlightedLines(path.join("/"), text))
    .then(highlighted => {
      if (highlighted === null) return;
      const targets = source.querySelectorAll(".code-text");
      for (const [i, line] of highlighted.entries()) targets[i]?.replaceChildren(...line);
    })
    .catch(err => console.warn("arborium:", err));
  return [...head, source];
}

async function* commitHistory(
  site: Site,
  start: string,
  scanned: (count: number) => void,
): AsyncGenerator<PathChange> {
  for await (const commit of log(site.repo, [start], HISTORY_PREFETCH)) {
    scanned(1);
    yield { commit, object: { oid: commit.tree, mode: TREE } };
  }
}

const snapshotKind = (object: LocatedObject): "tree" | "blob" =>
  (object.mode & 0o170000) === TREE ? "tree" : "blob";

export async function historyView(site: Site, view: View): Promise<Node[]> {
  const { oid, path } = view;
  const commitList = path.length === 0;
  const atTip = await kindAtTip(site, path);
  const list = (<ol class="log history-log" />) as HTMLOListElement;
  const status = (<p class="meta history-status" />) as HTMLElement;
  const control = (<p class="meta log-pagination" />) as HTMLElement;
  let scanned = 0;
  const scannedCommits = (count: number) => {
    scanned += count;
    status.textContent = `scanned ${plural(scanned, "commit")}`;
  };
  paginate<PathChange>({
    list,
    control,
    open: () => {
      scanned = 0;
      return commitList
        ? commitHistory(site, oid, scannedCommits)
        : pathHistory(site.repo, [oid], path, scannedCommits);
    },
    key: change => change.commit.oid,
    render: change => {
      // a path's history leads to the path as it was; the commit list, to the commits
      const target = !commitList && change.object
        ? canonical(site.page, { kind: snapshotKind(change.object), oid: change.commit.oid, path }, atTip)
        : `#commit/${change.commit.oid}`;
      const who = (
        <span class="who">
          <span>{change.commit.author.name}</span>
          <time>{identityDate(change.commit.author).slice(0, 10)}</time>
        </span>
      ) as HTMLElement;
      if (!change.object) who.append(<span class="deleted">deleted</span>);
      const item = (<li />) as HTMLLIElement;
      if (change.commit.changeId) {
        item.append(<a class="cid" href={target}>{change.commit.changeId.slice(0, 8)}</a>, " ");
      }
      item.append(
        <a class="sha" href={target}>{change.commit.oid.slice(0, 7)}</a>,
        who,
        <span class="msg">{change.commit.message.split("\n")[0]}</span>,
      );
      return item;
    },
    onShow: count => {
      status.replaceChildren(<span>{plural(count, commitList ? "commit" : "change")}</span>);
    },
    onError: err => {
      status.textContent = `history failed: ${String(err)}`;
    },
  });

  return [
    await topbar(site, view, [commitList ? "commit history" : "change history"]),
    status,
    list,
    control,
  ];
}